#include "lvgl.h"   // LVGL图形库
#include "stdlib.h" // 标准库函数（如rand）
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_err.h" // 错误码头文件
#include "esp_log.h"
#include "game.h"   // 标准库函数（如rand）
#include "ui_setting.h"
#include "hal_i2c.h"
#include "audio.h"
#include "pca9557pw.h"
#include "app_sr.h"
static const char *TAG = "pvz";

// 声明字体
LV_FONT_DECLARE(myFont);
LV_FONT_DECLARE(lv_font_montserrat_14);
// 游戏参数宏定义
#define max_quantity             15   // 每种角色最大数量15
#define zb_maxlive               10   // 僵尸最大血量10
#define zb_period                7000 // 僵尸生成周期7000ms
#define zidan_speed              20   // 子弹飞行速度(每20ms移动1像素)
#define shine_period             5000 // 阳光生成周期5000ms
#define zb_move_speed            200  // 僵尸移动速度(每200ms移动1像素)
#define plant_stackable          1    // 植物可叠加放置(1可/0不可)
#define sunflower_add_sun_period 5000 // 向日葵生成阳光周期5000ms

// 植物选择状态变量
static int nuclear_btn_select;      // 核弹按钮选中状态
static int cherry_btn_select;       // 樱桃炸弹按钮选中状态
static int chanzi_btn_select;       // 铲子按钮选中状态
static int sunflower_btn_select;    // 向日葵按钮选中状态
static int wandouflower_btn_select; // 豌豆射手按钮选中状态
static int wogua_btn_select;        // 窝瓜按钮选中状态

// LVGL对象指针
static lv_obj_t *nuclear_btn;      // 核弹按钮
static lv_obj_t *cherry_btn;       // 樱桃炸弹按钮
static lv_obj_t *wogua_btn;        // 窝瓜按钮
static lv_obj_t *chanzi_btn;       // 铲子按钮
static lv_obj_t *sunflower_btn;    // 向日葵按钮
static lv_obj_t *wandouflower_btn; // 豌豆射手按钮
static lv_obj_t *botton_exit;      // 退出按钮
static lv_obj_t *map1;             // 游戏地图
static lv_obj_t *screen;           // 主屏幕
// static lv_obj_t *lable_sun_score;  // 阳光分数标签
// static lv_obj_t *lable_right;      // 右侧标签(未使用)
// static lv_obj_t *lable_down;       // 底部标签(未使用)
static lv_obj_t *exit_ui;          // 退出界面
// 定时器对象
static lv_timer_t *timer_newzb;     // 新僵尸生成定时器
static lv_timer_t *timer_movezb;    // 僵尸移动定时器
static lv_timer_t *timer_newshine;  // 新阳光生成定时器
static lv_timer_t *timer_zidan_fly; // 子弹飞行定时器
// static lv_timer_t *timer_hit_test;  // 碰撞检测定时器(未使用)
// static lv_timer_t *timer_led;       // LED控制定时器(未使用)

// UI元素指针(部分未使用)
static lv_obj_t *panel;
static lv_obj_t *panellable;
static lv_obj_t *btext;
static lv_obj_t *score_lable; // 分数标签
static lv_obj_t *next_lable;
static lv_obj_t *gameover_botton;
static lv_obj_t *gameover_lable;
static lv_obj_t *exit_lable;
static int sun_score = 0; // 当前阳光值

// 声明图像资源
LV_IMG_DECLARE(pvz_map)          // 游戏地图
LV_IMG_DECLARE(zb1)              // 僵尸图像
LV_IMG_DECLARE(sunshine)         // 阳光图像
LV_IMG_DECLARE(wandou_img)       // 豌豆射手图像
LV_IMG_DECLARE(sun_img)          // 向日葵图像
LV_IMG_DECLARE(wogua_img)        // 窝瓜图像
LV_IMG_DECLARE(zidan_split_img)  // 子弹分裂效果
LV_IMG_DECLARE(cherry_img)       // 樱桃炸弹图像
LV_IMG_DECLARE(cherry_boom_img)  // 樱桃爆炸效果
LV_IMG_DECLARE(nuclear_img)      // 核弹图像
LV_IMG_DECLARE(nuclear_boom_img) // 核弹爆炸效果
LV_IMG_DECLARE(gameFail)         // 退出界面

// 定时器结构体
typedef struct
{
    lv_timer_t *timer; // 关联的定时器
    int alive;         // 是否激活
} timer_type;

// 窝瓜结构体
typedef struct
{
    lv_obj_t *wogua; // 窝瓜对象
    int alive;       // 是否存活
    int live;        // 生命值
    int x;           // X坐标
    int y;           // Y坐标
} wogua_type;

// 子弹结构体
typedef struct
{
    lv_obj_t *zidan; // 子弹对象
    int alive;       // 是否激活
    int x;           // X坐标
    int y;           // Y坐标
} zidan_type;

// 僵尸结构体
typedef struct
{
    lv_obj_t *zb; // 僵尸对象
    int alive;    // 是否存活
    int live;     // 生命值
    int x;        // X坐标
    int y;        // Y坐标
} zb_type;

// 向日葵结构体
typedef struct
{
    lv_obj_t *sunflower;        // 向日葵对象
    lv_timer_t *sunflowertimer; // 产阳光定时器
    int alive;                  // 是否存活
    int x;                      // X坐标
    int y;                      // Y坐标
} sunflower_type;

// 豌豆射手结构体
typedef struct
{
    lv_obj_t *wandouflower; // 豌豆对象
    lv_timer_t *zidantimer; // 子弹生成定时器
    int alive;              // 是否存活
    int x;                  // X坐标
    int y;                  // Y坐标
} wandou_type;

// 植物基类结构体(未使用)
typedef struct
{
    lv_obj_t *plant; // 植物对象
    int alive;       // 是否存活
    int x;           // X坐标
    int y;           // Y坐标
} plant_type;

// 阳光结构体
typedef struct
{
    lv_obj_t *shine; // 阳光对象
    int alive;       // 是否激活
    int x;           // X坐标
    int y;           // Y坐标
} shine_type;

// 游戏状态数组
static char map_flag[3][9] = { 0 };                      // 地图位置占用标志
static wogua_type wogua[max_quantity] = { 0 };           // 窝瓜数组
static timer_type add_zidan_timer[max_quantity] = { 0 }; // 子弹定时器数组(未使用)
static zidan_type zidan[max_quantity] = { 0 };           // 子弹数组
static sunflower_type sunflower[max_quantity] = { 0 };   // 向日葵数组
static wandou_type wandouflower[max_quantity] = { 0 };   // 豌豆射手数组
static shine_type shine[max_quantity] = { 0 };           // 阳光数组
static zb_type zb_matrix[max_quantity] = { 0 };          // 僵尸数组

/********************音乐相关的变量*********************/
// 全局任务控制变量
static TaskHandle_t music_task_handle = NULL;
static volatile bool music_playing = false;

// 函数前置声明
static void timer_cb1(lv_timer_t *t);
static void timer_cb2(lv_timer_t *t);
static void timer_cb3(lv_timer_t *t);
static void shine_del_cb1(lv_event_t *e);
static void anim_cb1(void *var, int32_t v);
static void anim_cb2(void *var, int32_t v);
static void cube_ready();
static void init_shine_zb();
static void lv_anim_exec_xcb(void *var, int32_t v);
static void ready_cb(lv_anim_t *var);
static void print_cubematrix();
static void all_clear(lv_event_t *e);
static void gameoverbotton_event_cb(lv_event_t *e);
static void shine_delect_cb(lv_anim_t *a);
static void sunflower_btn_cb(lv_event_t *e);
static void wandouflower_btn_cb(lv_event_t *e);
static void map_click_cb(lv_event_t *e);
static void add_zidan_cb(lv_timer_t *t);
static void zidan_move();
static void hit_test(lv_timer_t *t);
static void anim_zb_dead_cb(void *var, int32_t v);
static void anim_zb_delect_cb(lv_anim_t *a);
static void shine_start_cb1(void *var, int32_t v);
static void chanzi_btn_cb(lv_event_t *e);
static void sun_creat_cb(lv_timer_t *t);
static void wogua_btn_cb(lv_event_t *e);
static void nuclear_btn_cb(lv_event_t *e);
static void wogua_dead_cb(void *var, int32_t v);
static void wogua_dead_cb2(void *var, int32_t v);
static void wogua_delect_cb(lv_anim_t *a);
static void zb_move_cb(void *var, int32_t v);
static void zidan_split_cb(void *var, int32_t v);
static void zidan_split_delect_cb(lv_anim_t *a);
static void timer_led_cb(lv_timer_t *t);
static void exit_game_cb(lv_event_t *e);
static void plant_anim_cb(void *var, int32_t v);
static void zb_del_start_cb(lv_anim_t *a);
static void cherry_delete_cb(lv_anim_t *a);
static void cherry_anim_cb(void *var, int32_t v);
static void boom_delete_cb(lv_anim_t *a);
static void boom_anim_cb(void *var, int32_t v);
static void cherry_btn_cb(lv_event_t *e);
static void nuclear_boom_delete_cb(lv_anim_t *a);
static void nuclear_boom_anim_cb(void *var, int32_t v);
static void nuclear_delete_cb(lv_anim_t *a);
static void nuclear_anim_cb(void *var, int32_t v);
static void create_exit_ui(void);
// 游戏音乐播放任务
void pvz_bg_music_task(void *pvParameters);
/* 启动背景音乐 */
void start_bg_music(void);
/* 停止背景音乐 */
void stop_bg_music(void);
// 游戏入口函数
void pvz_start(void)
{
    //xTaskCreate(pvz_bg_music_task, "power_music_task", 4 * 1024, NULL, 5, NULL); // 播放开机音乐
    sun_score = 0; // 初始化阳光值
    // 重置所有按钮选择状态
    chanzi_btn_select = 0;
    sunflower_btn_select = 0;
    wandouflower_btn_select = 0;
    wogua_btn_select = 0;
    cherry_btn_select = 0;
    nuclear_btn_select = 0;

    // 创建主屏幕
    lv_obj_clear_flag(lv_scr_act(), LV_OBJ_FLAG_SCROLLABLE); // 禁止滑动
    screen = lv_tileview_create(lv_scr_act());               // 创建平铺视图
    lv_obj_clear_flag(screen, LV_OBJ_FLAG_SCROLLABLE);

    // 创建地图
    map1 = lv_img_create(screen);
    lv_img_set_src(map1, &pvz_map);
    lv_obj_clear_flag(map1, LV_OBJ_FLAG_SCROLLABLE);               // 禁止滑动
    lv_obj_add_event_cb(map1, map_click_cb, LV_EVENT_RELEASED, 0); // 添加地图点击事件

    // 创建分数标签
    score_lable = lv_label_create(map1);
    lv_obj_set_style_text_font(score_lable, &lv_font_montserrat_14, LV_PART_MAIN);
    lv_label_set_text_fmt(score_lable, "%d", sun_score);
    lv_obj_set_style_text_color(score_lable, lv_color_hex(0xffffff), LV_PART_MAIN);
    lv_obj_set_pos(score_lable, 12, 38);

    // 创建退出按钮 -
    botton_exit = lv_btn_create(map1);
    lv_obj_set_style_bg_color(botton_exit, lv_color_hex(0x6f3011), LV_PART_MAIN);
    lv_obj_set_pos(botton_exit, 254, 10);
    exit_lable = lv_label_create(botton_exit);
    lv_obj_set_style_text_font(exit_lable, &lv_font_montserrat_14, LV_PART_MAIN);
    lv_label_set_text(exit_lable, "<EXIT");
    lv_obj_set_style_text_color(exit_lable, lv_color_hex(0xffffff), LV_PART_MAIN);
    lv_obj_add_event_cb(botton_exit, create_exit_ui, LV_EVENT_RELEASED, 0);

    // 创建向日葵选择按钮 -
    sunflower_btn = lv_btn_create(map1);
    lv_obj_set_pos(sunflower_btn, 42, -2);
    lv_obj_set_size(sunflower_btn, 28, 45);
    lv_obj_set_style_bg_color(sunflower_btn, lv_color_hex(0x000000), LV_PART_MAIN);
    lv_obj_set_style_bg_opa(sunflower_btn, 160, LV_PART_MAIN);
    lv_obj_set_style_border_width(sunflower_btn, 2, LV_PART_MAIN);
    lv_obj_set_style_border_color(sunflower_btn, lv_color_hex(0xffffff), LV_PART_MAIN);
    lv_obj_set_style_border_opa(sunflower_btn, 0, LV_PART_MAIN);
    lv_obj_add_event_cb(sunflower_btn, sunflower_btn_cb, LV_EVENT_RELEASED, 0);
    lv_obj_clear_flag(sunflower_btn, LV_OBJ_FLAG_CLICKABLE); // 初始不可点击

    // 豌豆射手按钮 -
    wandouflower_btn = lv_btn_create(map1);
    lv_obj_set_pos(wandouflower_btn, 72, -2);
    lv_obj_set_size(wandouflower_btn, 28, 45);
    lv_obj_set_style_bg_color(wandouflower_btn, lv_color_hex(0x000000), LV_PART_MAIN);
    lv_obj_set_style_bg_opa(wandouflower_btn, 160, LV_PART_MAIN);
    lv_obj_set_style_border_width(wandouflower_btn, 2, LV_PART_MAIN);
    lv_obj_set_style_border_color(wandouflower_btn, lv_color_hex(0xffffff), LV_PART_MAIN);
    lv_obj_set_style_border_opa(wandouflower_btn, 0, LV_PART_MAIN);
    lv_obj_add_event_cb(wandouflower_btn, wandouflower_btn_cb, LV_EVENT_RELEASED, 0);
    lv_obj_clear_flag(wandouflower_btn, LV_OBJ_FLAG_CLICKABLE);

    // 倭瓜按钮 -
    wogua_btn = lv_btn_create(map1);
    lv_obj_set_pos(wogua_btn, 100, -2);
    lv_obj_set_size(wogua_btn, 28, 45);
    lv_obj_set_style_bg_color(wogua_btn, lv_color_hex(0x000000), LV_PART_MAIN);
    lv_obj_set_style_bg_opa(wogua_btn, 160, LV_PART_MAIN);
    lv_obj_set_style_border_width(wogua_btn, 2, LV_PART_MAIN);
    lv_obj_set_style_border_color(wogua_btn, lv_color_hex(0xffffff), LV_PART_MAIN);
    lv_obj_set_style_border_opa(wogua_btn, 0, LV_PART_MAIN);
    lv_obj_add_event_cb(wogua_btn, wogua_btn_cb, LV_EVENT_RELEASED, 0);
    lv_obj_clear_flag(wogua_btn, LV_OBJ_FLAG_CLICKABLE);
    // 樱桃炸弹按钮 -
    cherry_btn = lv_btn_create(map1);
    lv_obj_set_pos(cherry_btn, 129, -2);
    lv_obj_set_size(cherry_btn, 28, 45);
    lv_obj_set_style_bg_color(cherry_btn, lv_color_hex(0x000000), LV_PART_MAIN);
    lv_obj_set_style_bg_opa(cherry_btn, 160, LV_PART_MAIN);
    lv_obj_set_style_border_width(cherry_btn, 2, LV_PART_MAIN);
    lv_obj_set_style_border_color(cherry_btn, lv_color_hex(0xffffff), LV_PART_MAIN);
    lv_obj_set_style_border_opa(cherry_btn, 0, LV_PART_MAIN);
    lv_obj_add_event_cb(cherry_btn, cherry_btn_cb, LV_EVENT_RELEASED, 0);
    lv_obj_clear_flag(cherry_btn, LV_OBJ_FLAG_CLICKABLE);

    // 核弹按钮 -
    nuclear_btn = lv_btn_create(map1);
    lv_obj_set_pos(nuclear_btn, 158, -2);
    lv_obj_set_size(nuclear_btn, 28, 45);
    lv_obj_set_style_bg_color(nuclear_btn, lv_color_hex(0x000000), LV_PART_MAIN);
    lv_obj_set_style_bg_opa(nuclear_btn, 160, LV_PART_MAIN);
    lv_obj_set_style_border_width(nuclear_btn, 2, LV_PART_MAIN);
    lv_obj_set_style_border_color(nuclear_btn, lv_color_hex(0xffffff), LV_PART_MAIN);
    lv_obj_set_style_border_opa(nuclear_btn, 0, LV_PART_MAIN);
    lv_obj_add_event_cb(nuclear_btn, nuclear_btn_cb, LV_EVENT_RELEASED, 0);
    lv_obj_clear_flag(nuclear_btn, LV_OBJ_FLAG_CLICKABLE);

    // 创建铲子按钮 -
    chanzi_btn = lv_btn_create(map1);
    lv_obj_set_pos(chanzi_btn, 213, -1);
    lv_obj_set_size(chanzi_btn, 37, 50);
    lv_obj_set_style_shadow_opa(chanzi_btn, 0, LV_PART_MAIN);
    lv_obj_set_style_bg_opa(chanzi_btn, 0, LV_PART_MAIN);
    lv_obj_set_style_border_width(chanzi_btn, 2, LV_PART_MAIN);
    lv_obj_set_style_border_color(chanzi_btn, lv_color_hex(0xffffff), LV_PART_MAIN);
    lv_obj_set_style_border_opa(chanzi_btn, 0, LV_PART_MAIN);
    lv_obj_add_event_cb(chanzi_btn, chanzi_btn_cb, LV_EVENT_RELEASED, 0);

    timer_cb3(0); // 手动生成初始阳光

    // 创建游戏定时器
    timer_newzb = lv_timer_create(timer_cb1, zb_period, 0);        // 僵尸生成
    timer_movezb = lv_timer_create(timer_cb2, zb_move_speed, 0);   // 僵尸移动
    timer_newshine = lv_timer_create(timer_cb3, shine_period, 0);  // 阳光生成
    timer_zidan_fly = lv_timer_create(zidan_move, zidan_speed, 0); // 子弹移动

    start_bg_music(); // 启动背景音乐
}

// 窝瓜死亡动画回调1
void wogua_dead_cb(void *var, int32_t v)
{
    lv_obj_t *user = (lv_obj_t *)var;
    // 向右上角移动
    int x = lv_obj_get_x(user) + 1;
    int y = lv_obj_get_y(user) - 1;
    lv_obj_set_pos(user, x, y);
}

// 窝瓜死亡动画回调2
void wogua_dead_cb2(void *var, int32_t v)
{
    lv_obj_t *user = (lv_obj_t *)var;
    // 向下移动
    int y = lv_obj_get_y(user) + 1;
    lv_obj_set_y(user, y);
}

// 窝瓜死亡动画回调3（透明度变化）
void wogua_dead_cb3(void *var, int32_t v)
{
    lv_obj_t *user = (lv_obj_t *)var;
    lv_obj_set_style_img_opa(user, v, LV_PART_MAIN); // 设置透明度
}

// 窝瓜删除回调
void wogua_delect_cb(lv_anim_t *a)
{
    wogua_type *user = (wogua_type *)a->user_data;
    user->alive = 0;         // 标记为未激活
    lv_obj_del(user->wogua); // 删除对象
}

// 僵尸受伤回调（透明度变化）
void hit_zb_cb(void *var, int32_t v)
{
    lv_obj_t *user = (lv_obj_t *)var;
    lv_obj_set_style_img_opa(user, v, 0); // 设置透明度
}

// 核弹下落动画
void nuclear_anim_cb(void *var, int32_t v)
{
    lv_obj_t *nuclear = (lv_obj_t *)var;
    lv_obj_set_y(nuclear, v);          // 设置Y坐标
    lv_img_set_zoom(nuclear, 155 - v); // 缩放效果
}

// 核弹爆炸处理
void nuclear_delete_cb(lv_anim_t *a)
{
    lv_obj_t *nuclear = (lv_obj_t *)a->var;

    // 创建爆炸效果
    lv_obj_t *nuclear_boom = lv_img_create(map1);
    lv_img_set_src(nuclear_boom, &nuclear_boom_img);
    lv_obj_center(nuclear_boom);

    // 爆炸动画
    lv_anim_t a1;
    lv_anim_init(&a1);
    lv_anim_set_var(&a1, nuclear_boom);
    lv_anim_set_exec_cb(&a1, nuclear_boom_anim_cb);
    lv_anim_set_ready_cb(&a1, nuclear_boom_delete_cb);
    lv_anim_set_time(&a1, 1000);
    lv_anim_set_values(&a1, 0, 20);
    lv_anim_start(&a1);

    // 消灭所有僵尸
    for (int i = 0; i < max_quantity; i++) {
        if (zb_matrix[i].live > 0) {
            zb_matrix[i].live = 0;
            lv_anim_del(zb_matrix[i].zb, zb_move_cb); // 停止移动动画
            // 设置僵尸为黑色
            lv_obj_set_style_img_recolor(zb_matrix[i].zb, lv_color_hex(0x000000), 0);
            lv_obj_set_style_img_recolor_opa(zb_matrix[i].zb, 255, 0);

            // 播放僵尸死亡动画
            lv_anim_t a;
            lv_anim_init(&a);
            lv_anim_set_var(&a, zb_matrix[i].zb);
            lv_anim_set_exec_cb(&a, anim_zb_dead_cb);
            lv_anim_set_path_cb(&a, lv_anim_path_ease_in);
            lv_anim_set_time(&a, 2000);
            lv_anim_set_values(&a, 0, 200);
            lv_anim_set_user_data(&a, &zb_matrix[i]);
            lv_anim_set_ready_cb(&a, anim_zb_delect_cb);
            lv_anim_start(&a);
        }
    }

    lv_obj_del(nuclear); // 删除核弹
}

// 樱桃炸弹动画
void cherry_anim_cb(void *var, int32_t v)
{
    lv_obj_t *cherry = (lv_obj_t *)var;
    lv_img_set_zoom(cherry, 255 + v * 15); // 缩放效果
}

// 樱桃炸弹爆炸处理
void cherry_delete_cb(lv_anim_t *a)
{
    lv_obj_t *cherry = (lv_obj_t *)a->var;
    int x = lv_obj_get_x(cherry);
    int y = lv_obj_get_y(cherry);

    // 创建爆炸效果
    lv_obj_t *boom = lv_img_create(map1);
    lv_img_set_src(boom, &cherry_boom_img);
    lv_img_set_zoom(boom, 400);
    lv_obj_set_pos(boom, x - 30, y - 10);

    // 爆炸动画
    lv_anim_t a1;
    lv_anim_init(&a1);
    lv_anim_set_var(&a1, boom);
    lv_anim_set_exec_cb(&a1, boom_anim_cb);
    lv_anim_set_ready_cb(&a1, boom_delete_cb);
    lv_anim_set_time(&a1, 500);
    lv_anim_set_values(&a1, 0, 1);
    lv_anim_start(&a1);

    // 消灭范围内的僵尸
    for (int i = 0; i < max_quantity; i++) {
        if (zb_matrix[i].live > 0) {
            int zb_x = lv_obj_get_x(zb_matrix[i].zb);
            int zb_y = lv_obj_get_y(zb_matrix[i].zb);
            // 距离检测
            if (abs(zb_x - x) < 80 && abs(zb_y - y) < 80) {
                zb_matrix[i].live = 0;
                lv_anim_del(zb_matrix[i].zb, zb_move_cb);
                // 设置僵尸为黑色
                lv_obj_set_style_img_recolor(zb_matrix[i].zb, lv_color_hex(0x000000), 0);
                lv_obj_set_style_img_recolor_opa(zb_matrix[i].zb, 255, 0);

                // 播放僵尸死亡动画
                lv_anim_t a;
                lv_anim_init(&a);
                lv_anim_set_var(&a, zb_matrix[i].zb);
                lv_anim_set_exec_cb(&a, anim_zb_dead_cb);
                lv_anim_set_path_cb(&a, lv_anim_path_ease_in);
                lv_anim_set_time(&a, 2000);
                lv_anim_set_values(&a, 0, 200);
                lv_anim_set_user_data(&a, &zb_matrix[i]);
                lv_anim_set_ready_cb(&a, anim_zb_delect_cb);
                lv_anim_start(&a);
            }
        }
    }

    lv_obj_del(cherry); // 删除樱桃
}

// 爆炸效果删除回调
void boom_delete_cb(lv_anim_t *a)
{
    lv_obj_t *boom = (lv_obj_t *)a->var;
    lv_obj_del(boom); // 删除爆炸效果
}

// 爆炸动画回调（空实现）
void boom_anim_cb(void *var, int32_t v)
{
    return;
}

// 核弹爆炸动画
void nuclear_boom_anim_cb(void *var, int32_t v)
{
    lv_obj_t *nuclear_boom = (lv_obj_t *)var;
    lv_img_set_zoom(nuclear_boom, 255 + v * 20);
}

// 核弹爆炸删除回调
void nuclear_boom_delete_cb(lv_anim_t *a)
{
    lv_obj_t *nuclear_boom = (lv_obj_t *)a->var;
    lv_obj_del(nuclear_boom); // 删除爆炸效果
}

// 僵尸死亡动画
void anim_zb_dead_cb(void *var, int32_t v)
{
    lv_obj_t *user = (lv_obj_t *)var;
    if (v < 80) {
        lv_img_set_angle(user, -v * 10); // 旋转效果
    } else {
        lv_obj_set_style_img_opa(user, 415 - 2 * v, 0); // 透明度变化
    }
}

// 植物摆动动画
void plant_anim_cb(void *var, int32_t v)
{
    wandou_type *xxx = (wandou_type *)var;
    lv_img_set_angle(xxx->wandouflower, -v * 10); // 旋转

    // 上下移动
    if (v >= 0) {
        lv_obj_set_y(xxx->wandouflower, xxx->y * 54 + 62 + v / 2);
    } else {
        lv_obj_set_y(xxx->wandouflower, xxx->y * 54 + 62 - v / 2);
    }
}

// 僵尸删除回调
void anim_zb_delect_cb(lv_anim_t *a)
{
    zb_type *user = (zb_type *)a->user_data;
    user->alive = 0; // 标记为未激活
    user->live = 0;
    lv_obj_del(user->zb); // 删除对象
}

// LED定时器回调（空实现）
void timer_led_cb(lv_timer_t *t)
{
}

// 僵尸生成定时器回调
void timer_cb1(lv_timer_t *t)
{
    for (int j = 0; j < max_quantity; j++) {
        if (zb_matrix[j].alive == 0) { // 找到空闲位置
            zb_matrix[j].alive = 1;
            zb_matrix[j].live = zb_maxlive; // 设置满血量

            // 创建僵尸对象
            zb_matrix[j].zb = lv_img_create(map1);
            lv_img_set_src(zb_matrix[j].zb, &zb1);
            zb_matrix[j].y = rand() % 3; // 随机行
            zb_matrix[j].x = 320;        // 最右侧
            lv_obj_set_pos(zb_matrix[j].zb, 320, zb_matrix[j].y * 54 + 56);
            lv_img_set_pivot(zb_matrix[j].zb, 15, 59); // 设置旋转中心

            // 添加摇晃动画
            lv_anim_t a;
            lv_anim_init(&a);
            lv_anim_set_var(&a, zb_matrix[j].zb);
            lv_anim_set_exec_cb(&a, zb_move_cb);
            lv_anim_set_path_cb(&a, lv_anim_path_ease_in);
            lv_anim_set_time(&a, 4300);
            lv_anim_set_values(&a, -5, 10);
            lv_anim_set_playback_time(&a, 1900);
            lv_anim_set_repeat_count(&a, LV_ANIM_REPEAT_INFINITE); // 无限重复
            lv_anim_start(&a);

            return; // 一次只生成一个僵尸
        }
    }
}

// 僵尸移动定时器回调
void timer_cb2(lv_timer_t *t)
{
    for (int j = 0; j < max_quantity; j++) {
        if (zb_matrix[j].live > 0) {                       // 只处理存活的僵尸
            zb_matrix[j].x--;                              // 向左移动
            if (zb_matrix[j].x < -4) {
                /*游戏结束*/
                //发送点击事件
                if (botton_exit) {
                    //lv_event_send(botton_exit, LV_EVENT_RELEASED, NULL);
                    create_exit_ui();
                    return;
                }
            }
            lv_obj_set_x(zb_matrix[j].zb, zb_matrix[j].x); // 更新位置

        }
    }
}

// 阳光生成定时器回调
void timer_cb3(lv_timer_t *t)
{
    for (int j = 0; j < max_quantity; j++) {
        if (shine[j].alive == 0) { // 找到空闲位置
            shine[j].alive = 1;
            // 创建阳光对象
            shine[j].shine = lv_img_create(map1);
            lv_img_set_src(shine[j].shine, &sunshine);
            lv_obj_add_flag(shine[j].shine, LV_OBJ_FLAG_CLICKABLE); // 可点击
            // 随机位置
            shine[j].x = rand() % 260 + 30;
            shine[j].y = rand() % 150 + 50;
            lv_obj_set_pos(shine[j].shine, shine[j].x, shine[j].y);
            // 添加点击事件
            lv_obj_add_event_cb(shine[j].shine, shine_del_cb1, LV_EVENT_RELEASED, &shine[j]);

            // 添加浮动动画
            lv_anim_t a1;
            lv_anim_init(&a1);
            lv_anim_set_var(&a1, shine[j].shine);
            lv_anim_set_exec_cb(&a1, shine_start_cb1);
            lv_anim_set_path_cb(&a1, lv_anim_path_ease_out); // 最后慢
            lv_anim_set_time(&a1, 1000);                     // 1秒
            lv_anim_set_values(&a1, shine[j].y, shine[j].y + 20);
            lv_anim_set_user_data(&a1, &shine[j]);
            lv_anim_start(&a1);

            return; // 一次只生成一个阳光
        }
    }
}

// 阳光浮动动画
void shine_start_cb1(void *var, int32_t v)
{
    lv_obj_t *xxx = (lv_obj_t *)var;
    lv_obj_set_y(xxx, v); // 垂直移动
}

// 豌豆射手生成子弹回调
void add_zidan_cb(lv_timer_t *t)
{
    wandou_type *user = (wandou_type *)t->user_data;
    int x = user->x;
    int y = user->y;

    for (int i = 0; i < max_quantity; i++) {
        if (zidan[i].alive == 0) { // 找到空闲子弹位
            zidan[i].alive = 1;
            zidan[i].x = x * 49 + 40; // 初始位置在豌豆右侧
            zidan[i].y = y;

            // 创建子弹对象（圆形按钮）
            zidan[i].zidan = lv_btn_create(map1);
            lv_obj_set_pos(zidan[i].zidan, zidan[i].x, y * 52 + 69);
            lv_obj_set_size(zidan[i].zidan, 16, 16);
            lv_obj_set_style_bg_color(zidan[i].zidan, lv_color_hex(0x40ff40), LV_PART_MAIN);
            lv_obj_set_style_shadow_color(zidan[i].zidan, lv_color_hex(0x004000), LV_PART_MAIN);
            lv_obj_set_style_radius(zidan[i].zidan, 8, LV_PART_MAIN); // 圆形
            lv_obj_set_style_border_width(zidan[i].zidan, 2, LV_PART_MAIN);
            lv_obj_set_style_border_color(zidan[i].zidan, lv_color_hex(0x004000), LV_PART_MAIN);
            lv_obj_clear_flag(zidan[i].zidan, LV_OBJ_FLAG_CLICKABLE);
            return;
        }
    }
}

// 子弹移动处理
void zidan_move()
{
    // 移动所有激活的子弹
    for (int i = 0; i < max_quantity; i++) {
        if (zidan[i].alive == 1) {
            zidan[i].x += 5; // 向右移动

            if (zidan[i].x > 330) { // 超出右边界
                zidan[i].alive = 0;
                lv_obj_del(zidan[i].zidan); // 删除子弹
            } else {
                lv_obj_set_x(zidan[i].zidan, zidan[i].x); // 更新位置
            }
        }
    }

    // 子弹与僵尸碰撞检测
    for (int i = 0; i < max_quantity; i++) {
        if (zb_matrix[i].live > 0) { // 只处理存活的僵尸
            for (int j = 0; j < max_quantity; j++) {
                // 同行且距离小于6像素
                if (zidan[j].alive > 0 && zb_matrix[i].y == zidan[j].y &&
                    abs(zb_matrix[i].x - zidan[j].x) < 6) {
                    zb_matrix[i].live--;                    // 僵尸掉血
                    zidan[j].alive = 0;                     // 子弹消失
                    lv_img_set_angle(zb_matrix[i].zb, 100); // 僵尸抖动

                    // 创建子弹击中效果
                    lv_obj_t *zidan_split = lv_img_create(map1);
                    lv_img_set_src(zidan_split, &zidan_split_img);
                    lv_obj_set_pos(zidan_split, lv_obj_get_x(zidan[j].zidan) - 8,
                                   lv_obj_get_y(zidan[j].zidan) - 8);
                    lv_obj_del(zidan[j].zidan); // 删除子弹

                    // 子弹分裂动画
                    lv_anim_t a;
                    lv_anim_init(&a);
                    lv_anim_set_var(&a, zidan_split);
                    lv_anim_set_exec_cb(&a, zidan_split_cb);
                    lv_anim_set_path_cb(&a, lv_anim_path_linear);
                    lv_anim_set_time(&a, 500);
                    lv_anim_set_values(&a, 0, 1);
                    lv_anim_set_ready_cb(&a, zidan_split_delect_cb);
                    lv_anim_start(&a);

                    // 僵尸受伤闪烁效果
                    lv_anim_t a1;
                    lv_anim_init(&a1);
                    lv_anim_set_var(&a1, zb_matrix[i].zb);
                    lv_anim_set_exec_cb(&a1, hit_zb_cb);
                    lv_anim_set_path_cb(&a1, lv_anim_path_linear);
                    lv_anim_set_time(&a1, 300);
                    lv_anim_set_values(&a1, 120, 255);
                    lv_anim_start(&a1);

                    // 检查僵尸是否死亡
                    if (zb_matrix[i].live == 0) {
                        lv_anim_del(zb_matrix[i].zb, zb_move_cb); // 停止移动动画
                        // 设置僵尸为黑色
                        lv_obj_set_style_img_recolor(zb_matrix[i].zb, lv_color_hex(0x000000), 0);
                        lv_obj_set_style_img_recolor_opa(zb_matrix[i].zb, 255, 0); // 完全不透明

                        // 播放死亡动画
                        lv_anim_t a;
                        lv_anim_init(&a);
                        lv_anim_set_var(&a, zb_matrix[i].zb);
                        lv_anim_set_exec_cb(&a, anim_zb_dead_cb);
                        lv_anim_set_path_cb(&a, lv_anim_path_ease_in);
                        lv_anim_set_time(&a, 2000);
                        lv_anim_set_values(&a, 0, 200);
                        lv_anim_set_user_data(&a, &zb_matrix[i]);
                        lv_anim_set_ready_cb(&a, anim_zb_delect_cb);
                        lv_anim_start(&a);
                        break;
                    }
                }
            }
        }
    }

    // 窝瓜与僵尸碰撞检测
    for (int i = 0; i < max_quantity; i++) {
        if (zb_matrix[i].live > 0) { // 存活的僵尸
            for (int j = 0; j < max_quantity; j++) {
                // 同行且距离小于80像素
                if (wogua[j].live > 0 && zb_matrix[i].y == wogua[j].y &&
                    abs(zb_matrix[i].x - wogua[j].x * 49) < 80) {
                    wogua[j].live = 0;     // 窝瓜消失
                    zb_matrix[i].live = 0; // 僵尸死亡

                    // 窝瓜死亡动画1（右上抛）
                    lv_anim_t a2;
                    lv_anim_init(&a2);
                    lv_anim_set_var(&a2, wogua[j].wogua);
                    lv_anim_set_exec_cb(&a2, wogua_dead_cb);
                    lv_anim_set_path_cb(&a2, lv_anim_path_ease_in);
                    lv_anim_set_time(&a2, 300);
                    lv_anim_set_values(&a2, 0, 80);
                    lv_anim_start(&a2);

                    // 窝瓜死亡动画2（下落）
                    lv_anim_t a3;
                    lv_anim_init(&a3);
                    lv_anim_set_var(&a3, wogua[j].wogua);
                    lv_anim_set_exec_cb(&a3, wogua_dead_cb2);
                    lv_anim_set_path_cb(&a3, lv_anim_path_ease_in);
                    lv_anim_set_time(&a3, 300);
                    lv_anim_set_delay(&a3, 600);
                    lv_anim_set_values(&a3, 0, 100);
                    lv_anim_start(&a3);

                    // 窝瓜死亡动画3（淡出）
                    lv_anim_t a4;
                    lv_anim_init(&a4);
                    lv_anim_set_var(&a4, wogua[j].wogua);
                    lv_anim_set_exec_cb(&a4, wogua_dead_cb3);
                    lv_anim_set_path_cb(&a4, lv_anim_path_ease_in);
                    lv_anim_set_time(&a4, 1000);
                    lv_anim_set_delay(&a4, 700);
                    lv_anim_set_values(&a4, 255, 0);
                    lv_anim_set_user_data(&a4, &wogua[j]);
                    lv_anim_set_ready_cb(&a4, wogua_delect_cb);
                    lv_anim_start(&a4);

                    // 僵尸死亡动画
                    lv_anim_del(zb_matrix[i].zb, zb_move_cb); // 停止移动
                    lv_anim_t a;
                    lv_anim_init(&a);
                    lv_anim_set_var(&a, zb_matrix[i].zb);
                    lv_anim_set_exec_cb(&a, anim_zb_dead_cb);
                    lv_anim_set_path_cb(&a, lv_anim_path_ease_in);
                    lv_anim_set_start_cb(&a, zb_del_start_cb);
                    lv_anim_set_time(&a, 2000);
                    lv_anim_set_delay(&a, 1000);
                    lv_anim_set_values(&a, 0, 200);
                    lv_anim_set_user_data(&a, &zb_matrix[i]);
                    lv_anim_set_ready_cb(&a, anim_zb_delect_cb);
                    lv_anim_start(&a);
                    lv_img_set_pivot(zb_matrix[i].zb, 15, 59);
                    break;
                }
            }
        }
    }
}

// 僵尸删除开始回调
void zb_del_start_cb(lv_anim_t *a)
{
    lv_obj_t *xxx = (lv_obj_t *)a->var;
    // 设置僵尸为黑色
    lv_obj_set_style_img_recolor(xxx, lv_color_hex(0x000000), 0);
    lv_obj_set_style_img_recolor_opa(xxx, 255, 0);
}

// 阳光点击回调
void shine_del_cb1(lv_event_t *e)
{
    shine_type *user = (shine_type *)lv_event_get_user_data(e);
    lv_anim_del(user->shine, shine_start_cb1);             // 停止浮动动画
    lv_obj_clear_flag(user->shine, LV_OBJ_FLAG_CLICKABLE); // 禁用点击

    // 阳光飞向分数栏动画1（水平）
    lv_anim_t a1;
    lv_anim_init(&a1);
    lv_anim_set_var(&a1, user->shine);
    lv_anim_set_exec_cb(&a1, anim_cb1);
    lv_anim_set_path_cb(&a1, lv_anim_path_ease_out);
    lv_anim_set_time(&a1, 500);
    lv_anim_set_values(&a1, user->x, 10);
    lv_anim_start(&a1);

    // 阳光飞向分数栏动画2（垂直）
    lv_anim_t a2;
    lv_anim_init(&a2);
    lv_anim_set_var(&a2, user->shine);
    lv_anim_set_exec_cb(&a2, anim_cb2);
    lv_anim_set_path_cb(&a2, lv_anim_path_ease_out);
    lv_anim_set_time(&a2, 500);
    lv_anim_set_values(&a2, lv_obj_get_y(user->shine), 0);
    lv_anim_set_user_data(&a2, user);
    lv_anim_set_ready_cb(&a2, shine_delect_cb);
    lv_anim_start(&a2);
}

// 子弹分裂动画（空实现）
void zidan_split_cb(void *var, int32_t v)
{
}

// 子弹分裂删除回调
void zidan_split_delect_cb(lv_anim_t *a)
{
    lv_obj_t *xxx = (lv_obj_t *)a->var;
    lv_obj_del(xxx); // 删除效果对象
}

// 僵尸摇晃动画
void zb_move_cb(void *var, int32_t v)
{
    lv_obj_t *xxx = (lv_obj_t *)var;
    lv_img_set_angle(xxx, v * 10); // 旋转角度
}

// 水平移动动画
void anim_cb1(void *var, int32_t v)
{
    lv_obj_t *xxx = (lv_obj_t *)var;
    lv_obj_set_x(xxx, v); // 设置X坐标
}

// 垂直移动动画
void anim_cb2(void *var, int32_t v)
{
    lv_obj_t *xxx = (lv_obj_t *)var;
    lv_obj_set_y(xxx, v); // 设置Y坐标
}

// 阳光收集完成回调
void shine_delect_cb(lv_anim_t *a)
{
    shine_type *user = (shine_type *)a->user_data;
    user->alive = 0;                                     // 标记为未激活
    lv_obj_del(user->shine);                             // 删除阳光对象
    sun_score += 50;                                     // 增加阳光值
    lv_label_set_text_fmt(score_lable, "%d", sun_score); // 更新分数显示

    // 根据阳光值解锁植物
    if (sun_score > 49) {                                        // 向日葵
        lv_obj_set_style_bg_opa(sunflower_btn, 0, LV_PART_MAIN); // 透明背景
        lv_obj_add_flag(sunflower_btn, LV_OBJ_FLAG_CLICKABLE);   // 可点击
    }
    if (sun_score > 99) { //
        lv_obj_set_style_bg_opa(wandouflower_btn, 0, LV_PART_MAIN);
        lv_obj_add_flag(wandouflower_btn, LV_OBJ_FLAG_CLICKABLE);
    }
    if (sun_score > 199) {
        lv_obj_set_style_bg_opa(wogua_btn, 0, LV_PART_MAIN);
        lv_obj_add_flag(wogua_btn, LV_OBJ_FLAG_CLICKABLE);
    }
    if (sun_score > 299) {
        lv_obj_set_style_bg_opa(cherry_btn, 0, LV_PART_MAIN);
        lv_obj_add_flag(cherry_btn, LV_OBJ_FLAG_CLICKABLE);
    }
    if (sun_score > 399) {
        lv_obj_set_style_bg_opa(nuclear_btn, 0, LV_PART_MAIN);
        lv_obj_add_flag(nuclear_btn, LV_OBJ_FLAG_CLICKABLE);
    }
}

/********************************************各种按钮回调函数***********************************************************************/
// 向日葵按钮回调
void sunflower_btn_cb(lv_event_t *e)
{
    if (sunflower_btn_select == 0) {
        // 选中向日葵，取消其他按钮选中状态
        lv_obj_set_style_border_opa(sunflower_btn, 255, LV_PART_MAIN); //边框显示
        lv_obj_set_style_border_opa(wandouflower_btn, 0, LV_PART_MAIN);
        lv_obj_set_style_border_opa(wogua_btn, 0, LV_PART_MAIN);
        lv_obj_set_style_border_opa(cherry_btn, 0, LV_PART_MAIN);
        lv_obj_set_style_border_opa(chanzi_btn, 0, LV_PART_MAIN);
        lv_obj_set_style_border_opa(nuclear_btn, 0, LV_PART_MAIN);
        lv_obj_add_flag(map1, LV_OBJ_FLAG_CLICKABLE); // 地图可点击
        sunflower_btn_select = 1;
        // 重置其他按钮状态
        wandouflower_btn_select = 0;
        chanzi_btn_select = 0;
        wogua_btn_select = 0;
        cherry_btn_select = 0;
        nuclear_btn_select = 0;
    } else {
        // 取消选中
        lv_obj_set_style_border_opa(sunflower_btn, 0, LV_PART_MAIN);
        sunflower_btn_select = 0;
    }
}
// 豌豆射手按钮回调
void wandouflower_btn_cb(lv_event_t *e)
{
    if (wandouflower_btn_select == 0) {
        lv_obj_set_style_border_opa(sunflower_btn, 0, LV_PART_MAIN);
        lv_obj_set_style_border_opa(wandouflower_btn, 255, LV_PART_MAIN);
        lv_obj_set_style_border_opa(wogua_btn, 0, LV_PART_MAIN);
        lv_obj_set_style_border_opa(chanzi_btn, 0, LV_PART_MAIN);
        lv_obj_set_style_border_opa(cherry_btn, 0, LV_PART_MAIN);
        lv_obj_set_style_border_opa(nuclear_btn, 0, LV_PART_MAIN);
        lv_obj_add_flag(map1, LV_OBJ_FLAG_CLICKABLE);
        sunflower_btn_select = 0;
        wandouflower_btn_select = 1;
        chanzi_btn_select = 0;
        wogua_btn_select = 0;
        cherry_btn_select = 0;
        nuclear_btn_select = 0;
    } else {
        lv_obj_set_style_border_opa(wandouflower_btn, 0, LV_PART_MAIN);
        wandouflower_btn_select = 0;
    }
}
// 窝瓜按钮回调
void wogua_btn_cb(lv_event_t *e)
{
    if (wogua_btn_select == 0) {
        // 选中窝瓜
        lv_obj_set_style_border_opa(sunflower_btn, 0, LV_PART_MAIN);
        lv_obj_set_style_border_opa(wandouflower_btn, 0, LV_PART_MAIN);
        lv_obj_set_style_border_opa(wogua_btn, 255, LV_PART_MAIN);
        lv_obj_set_style_border_opa(chanzi_btn, 0, LV_PART_MAIN);
        lv_obj_set_style_border_opa(cherry_btn, 0, LV_PART_MAIN);
        lv_obj_set_style_border_opa(nuclear_btn, 0, LV_PART_MAIN);
        lv_obj_add_flag(map1, LV_OBJ_FLAG_CLICKABLE);
        sunflower_btn_select = 0;
        wandouflower_btn_select = 0;
        wogua_btn_select = 1;
        chanzi_btn_select = 0;
        cherry_btn_select = 0;
        nuclear_btn_select = 0;
    } else // 取消选中
    {
        lv_obj_set_style_border_opa(wogua_btn, 0, LV_PART_MAIN);
        wogua_btn_select = 0;
    }
}
// 樱桃炸弹按钮回调
void cherry_btn_cb(lv_event_t *e)
{
    if (cherry_btn_select == 0) {
        lv_obj_set_style_border_opa(cherry_btn, 255, LV_PART_MAIN);
        lv_obj_set_style_border_opa(sunflower_btn, 0, LV_PART_MAIN);
        lv_obj_set_style_border_opa(wandouflower_btn, 0, LV_PART_MAIN);
        lv_obj_set_style_border_opa(wogua_btn, 0, LV_PART_MAIN);
        lv_obj_set_style_border_opa(chanzi_btn, 0, LV_PART_MAIN);
        lv_obj_add_flag(map1, LV_OBJ_FLAG_CLICKABLE);
        lv_obj_set_style_border_opa(nuclear_btn, 0, LV_PART_MAIN);
        sunflower_btn_select = 0;
        wandouflower_btn_select = 0;
        wogua_btn_select = 0;
        chanzi_btn_select = 0;
        cherry_btn_select = 1;
        nuclear_btn_select = 0;
    } else {
        lv_obj_set_style_border_opa(cherry_btn, 0, LV_PART_MAIN);
        cherry_btn_select = 0;
    }
}
// 核弹按钮回调
void nuclear_btn_cb(lv_event_t *e)
{
    if (nuclear_btn_select == 0) {
        lv_obj_set_style_border_opa(cherry_btn, 0, LV_PART_MAIN);
        lv_obj_set_style_border_opa(sunflower_btn, 0, LV_PART_MAIN);
        lv_obj_set_style_border_opa(wandouflower_btn, 0, LV_PART_MAIN);
        lv_obj_set_style_border_opa(wogua_btn, 0, LV_PART_MAIN);
        lv_obj_set_style_border_opa(chanzi_btn, 0, LV_PART_MAIN);
        lv_obj_add_flag(map1, LV_OBJ_FLAG_CLICKABLE);
        lv_obj_set_style_border_opa(nuclear_btn, 255, LV_PART_MAIN);
        sunflower_btn_select = 0;
        wandouflower_btn_select = 0;
        wogua_btn_select = 0;
        chanzi_btn_select = 0;
        cherry_btn_select = 0;
        nuclear_btn_select = 1;
    } else {
        lv_obj_set_style_border_opa(nuclear_btn, 0, LV_PART_MAIN);
        nuclear_btn_select = 0;
    }
}
// 铲子按钮回调
void chanzi_btn_cb(lv_event_t *e)
{
    if (chanzi_btn_select == 0) {
        // 选中铲子
        lv_obj_set_style_border_opa(sunflower_btn, 0, LV_PART_MAIN);
        lv_obj_set_style_border_opa(wandouflower_btn, 0, LV_PART_MAIN);
        lv_obj_set_style_border_opa(wogua_btn, 0, LV_PART_MAIN);
        lv_obj_set_style_border_opa(cherry_btn, 0, LV_PART_MAIN);
        lv_obj_set_style_border_opa(chanzi_btn, 255, LV_PART_MAIN);
        lv_obj_set_style_border_opa(nuclear_btn, 0, LV_PART_MAIN);
        lv_obj_add_flag(map1, LV_OBJ_FLAG_CLICKABLE);
        sunflower_btn_select = 0;
        wandouflower_btn_select = 0;
        wogua_btn_select = 0;
        chanzi_btn_select = 1;
        cherry_btn_select = 0;
    } else {
        // 取消选中
        lv_obj_set_style_border_opa(chanzi_btn, 0, LV_PART_MAIN);
        chanzi_btn_select = 0;
    }
}
/********************************************各种按钮回调函数 END***********************************************************************/

// 地图点击回调（核心交互函数）
void map_click_cb(lv_event_t *e)
{
    lv_point_t click_point;
    lv_indev_get_point(lv_indev_get_act(), &click_point); // 获取点击坐标
    int x = click_point.x / 40;                           // 转换为网格坐标
    int y = (click_point.y - 60) / 60;

    // 樱桃炸弹放置
    if (cherry_btn_select && (sun_score > 299)) {
        // 创建樱桃
        lv_obj_t *cherry = lv_img_create(map1);
        lv_img_set_src(cherry, &cherry_img);
        lv_obj_clear_flag(cherry, LV_OBJ_FLAG_CLICKABLE); // 禁止点击
        lv_obj_set_pos(cherry, x * 49 + 20, y * 54 + 44);

        // 樱桃爆炸动画
        lv_anim_t a;
        lv_anim_init(&a);
        lv_anim_set_var(&a, cherry);
        lv_anim_set_exec_cb(&a, cherry_anim_cb);
        lv_anim_set_ready_cb(&a, cherry_delete_cb);
        lv_anim_set_path_cb(&a, lv_anim_path_ease_out);
        lv_anim_set_time(&a, 1000);
        lv_anim_set_values(&a, 0, 10);
        lv_anim_start(&a);

        sun_score -= 300; // 消耗阳光
        lv_label_set_text_fmt(score_lable, "%d", sun_score);
        lv_obj_clear_flag(map1, LV_OBJ_FLAG_CLICKABLE); // 禁止点击
        cherry_btn_select = 0;
        lv_obj_set_style_border_opa(cherry_btn, 0, LV_PART_MAIN); // 取消选中
        goto new_score;                                           // 跳转更新阳光状态
    }

    // 核弹放置
    if (nuclear_btn_select && (sun_score > 399)) {
        lv_obj_t *nuclear = lv_img_create(map1);
        lv_img_set_src(nuclear, &nuclear_img);
        lv_obj_clear_flag(nuclear, LV_OBJ_FLAG_CLICKABLE);
        lv_obj_set_pos(nuclear, x * 49 + 10, y * 54 + 70);

        lv_anim_t a;
        lv_anim_init(&a);
        lv_anim_set_var(&a, nuclear);
        lv_anim_set_exec_cb(&a, nuclear_anim_cb);
        lv_anim_set_ready_cb(&a, nuclear_delete_cb);
        lv_anim_set_path_cb(&a, lv_anim_path_ease_out);
        lv_anim_set_time(&a, 2000);
        lv_anim_set_values(&a, -100, 120);
        lv_anim_start(&a);

        sun_score -= 400;
        lv_label_set_text_fmt(score_lable, "%d", sun_score);
        lv_obj_clear_flag(map1, LV_OBJ_FLAG_CLICKABLE);
        nuclear_btn_select = 0;
        lv_obj_set_style_border_opa(nuclear_btn, 0, LV_PART_MAIN);
        goto new_score;
    }
// 非叠加模式检查位置占用
#if (plant_stackable != 1)
    if (map_flag[y][x])
        return; // 位置被占用则返回
#endif

    // 放置向日葵
    if (sunflower_btn_select && (sun_score > 49)) {
        for (int j = 0; j < max_quantity; j++) {
            if (sunflower[j].alive == 0) { // 找到空闲位置
#if (plant_stackable != 1)
                map_flag[y][x] = 1; // 标记位置占用
#endif

                sunflower[j].alive = 1;
                sunflower[j].x = x;
                sunflower[j].y = y;
                // 创建向日葵
                sunflower[j].sunflower = lv_img_create(map1);
                lv_img_set_src(sunflower[j].sunflower, &sun_img);
                lv_obj_clear_flag(sunflower[j].sunflower, LV_OBJ_FLAG_CLICKABLE);
                lv_obj_set_pos(sunflower[j].sunflower, x * 37 + 10, y * 54 + 70);
                lv_img_set_pivot(sunflower[j].sunflower, 23, 55); // 旋转中心

                // 添加摆动动画
                lv_anim_t a;
                lv_anim_init(&a);
                lv_anim_set_var(&a, &sunflower[j]);
                lv_anim_set_exec_cb(&a, plant_anim_cb);
                lv_anim_set_path_cb(&a, lv_anim_path_ease_in_out);
                lv_anim_set_time(&a, 1000);
                lv_anim_set_values(&a, -5, 5);
                lv_anim_set_playback_time(&a, 1000);
                lv_anim_set_repeat_count(&a, LV_ANIM_REPEAT_INFINITE);
                lv_anim_start(&a);

                sun_score -= 50; // 消耗阳光
                lv_label_set_text_fmt(score_lable, "%d", sun_score);
                lv_obj_clear_flag(map1, LV_OBJ_FLAG_CLICKABLE);
                // 创建产阳光定时器
                sunflower[j].sunflowertimer = lv_timer_create(sun_creat_cb, sunflower_add_sun_period, &sunflower[j]);
                lv_obj_set_style_border_opa(sunflower_btn, 0, LV_PART_MAIN);
                break;
            }
        }
    }

    // 放置豌豆射手
    if (wandouflower_btn_select && (sun_score > 99)) {
        for (int j = 0; j < max_quantity; j++) {
            if (wandouflower[j].alive == 0) {
#if (plant_stackable != 1)
                map_flag[y][x] = 1;
#endif
                wandouflower[j].alive = 1;
                wandouflower[j].x = x;
                wandouflower[j].y = y;
                wandouflower[j].wandouflower = lv_img_create(map1);
                lv_img_set_src(wandouflower[j].wandouflower, &wandou_img);
                lv_obj_clear_flag(wandouflower[j].wandouflower, LV_OBJ_FLAG_CLICKABLE);
                lv_obj_set_pos(wandouflower[j].wandouflower, x * 36 + 10, y * 60 + 30);
                lv_img_set_pivot(wandouflower[j].wandouflower, 27, 50);

                lv_anim_t a;
                lv_anim_init(&a);
                lv_anim_set_var(&a, &wandouflower[j]);
                lv_anim_set_exec_cb(&a, plant_anim_cb);
                lv_anim_set_path_cb(&a, lv_anim_path_ease_in_out);
                lv_anim_set_time(&a, 1000);
                lv_anim_set_values(&a, -5, 5);
                lv_anim_set_playback_time(&a, 1000);
                lv_anim_set_repeat_count(&a, LV_ANIM_REPEAT_INFINITE);
                lv_anim_start(&a);

                sun_score -= 100;
                lv_label_set_text_fmt(score_lable, "%d", sun_score);
                lv_obj_clear_flag(map1, LV_OBJ_FLAG_CLICKABLE);
                wandouflower_btn_select = 0;
                lv_obj_set_style_border_opa(wandouflower_btn, 0, LV_PART_MAIN);
                //创建产生子弹定时器
                wandouflower[j].zidantimer = lv_timer_create(add_zidan_cb, 2000, &wandouflower[j]);
                break;
            }
        }
    }

    // 放置窝瓜

    if (wogua_btn_select && (sun_score > 199)) {
        for (int j = 0; j < max_quantity; j++) {
            if (wogua[j].alive == 0) {
#if (plant_stackable != 1)
                map_flag[y][x] = 1;
#endif
                wogua[j].alive = 1;
                wogua[j].live = 1;
                wogua[j].x = x;
                wogua[j].y = y;
                wogua[j].wogua = lv_img_create(map1);
                lv_img_set_src(wogua[j].wogua, &wogua_img);
                lv_obj_clear_flag(wogua[j].wogua, LV_OBJ_FLAG_CLICKABLE);
                lv_obj_set_pos(wogua[j].wogua, x * 49 + 8, y * 54 + 70);
                sun_score -= 200;
                lv_label_set_text_fmt(score_lable, "%d", sun_score);
                lv_obj_clear_flag(map1, LV_OBJ_FLAG_CLICKABLE);
                wogua_btn_select = 0;
                lv_obj_set_style_border_opa(wogua_btn, 0, LV_PART_MAIN);

                break;
            }
        }
    }
    // 铲子功能
    if (chanzi_btn_select) {
        for (int j = 0; j < max_quantity; j++) {
            // 移除豌豆射手
            if (wandouflower[j].alive == 1 && wandouflower[j].x == x && wandouflower[j].y == y) {
#if (plant_stackable != 1)
                map_flag[y][x] = 0; // 清除位置占用
#endif
                wandouflower[j].alive = 0;
                wandouflower[j].x = 0;
                wandouflower[j].y = 0;
                lv_anim_del(&wandouflower[j], plant_anim_cb); // 停止动画
                lv_obj_del(wandouflower[j].wandouflower);     // 删除对象
                lv_timer_del(wandouflower[j].zidantimer);     // 删除定时器
                chanzi_btn_select = 0;
                lv_obj_set_style_border_opa(chanzi_btn, 0, LV_PART_MAIN);
                lv_obj_clear_flag(map1, LV_OBJ_FLAG_CLICKABLE);
                break;
            }
            // 移除向日葵
            if (sunflower[j].alive == 1 && sunflower[j].x == x && sunflower[j].y == y) {
#if (plant_stackable != 1)
                map_flag[y][x] = 0;
#endif
                sunflower[j].alive = 0;
                sunflower[j].x = 0;
                sunflower[j].y = 0;
                lv_anim_del(&sunflower[j], plant_anim_cb);
                lv_obj_del(sunflower[j].sunflower);
                lv_timer_del(sunflower[j].sunflowertimer);
                chanzi_btn_select = 0;
                lv_obj_set_style_border_opa(chanzi_btn, 0, LV_PART_MAIN);
                lv_obj_clear_flag(map1, LV_OBJ_FLAG_CLICKABLE);
                break;
            }
            // 移除窝瓜（类似处理）
            if (wogua[j].alive == 1 && wogua[j].x == x && wogua[j].y == y) {
#if (plant_stackable != 1)
                map_flag[y][x] = 0;
#endif
                wogua[j].alive = 0;
                wogua[j].x = 0;
                wogua[j].y = 0;
                lv_obj_del(wogua[j].wogua);
                chanzi_btn_select = 0;
                lv_obj_set_style_border_opa(chanzi_btn, 0, LV_PART_MAIN);
                lv_obj_clear_flag(map1, LV_OBJ_FLAG_CLICKABLE);
                break;
            }
        }
    }

new_score:
    // 阳光不足时锁定植物
    if (sun_score < 50) {
        lv_obj_set_style_bg_opa(sunflower_btn, 160, LV_PART_MAIN);
        lv_obj_clear_flag(sunflower_btn, LV_OBJ_FLAG_CLICKABLE);
    }
    if (sun_score < 100) {
        lv_obj_set_style_bg_opa(wandouflower_btn, 160, LV_PART_MAIN);
        lv_obj_clear_flag(wandouflower_btn, LV_OBJ_FLAG_CLICKABLE);
    }
    if (sun_score < 200) {
        lv_obj_set_style_bg_opa(wogua_btn, 160, LV_PART_MAIN);
        lv_obj_clear_flag(wogua_btn, LV_OBJ_FLAG_CLICKABLE);
    }
    if (sun_score < 300) {
        lv_obj_set_style_bg_opa(cherry_btn, 160, LV_PART_MAIN);
        lv_obj_clear_flag(cherry_btn, LV_OBJ_FLAG_CLICKABLE);
    }
    if (sun_score < 400) {
        lv_obj_set_style_bg_opa(nuclear_btn, 160, LV_PART_MAIN);
        lv_obj_clear_flag(nuclear_btn, LV_OBJ_FLAG_CLICKABLE);
    }
}

// 向日葵生成阳光回调
void sun_creat_cb(lv_timer_t *t)
{
    sunflower_type *user = (sunflower_type *)t->user_data;
    int x = user->x;
    int y = user->y;

    for (int j = 0; j < max_quantity; j++) {
        if (shine[j].alive == 0) { // 找到空闲阳光位
            shine[j].alive = 1;
            // 在向日葵位置创建阳光
            shine[j].shine = lv_img_create(map1);
            lv_img_set_src(shine[j].shine, &sunshine);
            lv_obj_add_flag(shine[j].shine, LV_OBJ_FLAG_CLICKABLE);
            shine[j].x = x * 49 + 20;
            shine[j].y = y * 54 + 44;
            lv_obj_set_pos(shine[j].shine, shine[j].x, shine[j].y);
            // 添加点击事件
            lv_obj_add_event_cb(shine[j].shine, shine_del_cb1, LV_EVENT_RELEASED, &shine[j]);

            // 浮动动画
            lv_anim_t a1;
            lv_anim_init(&a1);
            lv_anim_set_var(&a1, shine[j].shine);
            lv_anim_set_exec_cb(&a1, shine_start_cb1);
            lv_anim_set_path_cb(&a1, lv_anim_path_ease_out);
            lv_anim_set_time(&a1, 1000);
            lv_anim_set_values(&a1, shine[j].y, shine[j].y + 20);
            lv_anim_set_user_data(&a1, &shine[j]);
            lv_anim_start(&a1);

            return;
        }
    }
}

// 初始化游戏对象
void init_shine_zb()
{
    for (int j = 0; j < max_quantity; j++) {
        shine[j].alive = 0;     // 重置阳光
        zb_matrix[j].alive = 0; // 重置僵尸
        zb_matrix[j].live = 0;
        wogua[j].alive = 0; // 重置窝瓜
        wogua[j].live = 0;
        zidan[j].alive = 0; // 重置子弹

        // 重置豌豆射手
        if (wandouflower[j].alive == 1) {
            wandouflower[j].alive = 0;
            lv_timer_del(wandouflower[j].zidantimer); // 删除子弹定时器
        }

        // 重置向日葵
        if (sunflower[j].alive == 1) {
            sunflower[j].alive = 0;
            lv_timer_del(sunflower[j].sunflowertimer); // 删除阳光定时器
        }
    }

// 重置地图占用标志
#if (plant_stackable != 1)
    for (int i = 0; i < 9; i++) {
        for (int j = 0; j < 3; j++) {
            map_flag[j][i] = 0;
        }
    }
#endif
}
static void stop_pvz_game(void)
{
    lv_anim_del_all(); // 删除所有动画

    // 删除所有定时器
    lv_timer_del(timer_newzb);
    lv_timer_del(timer_movezb);
    lv_timer_del(timer_newshine);
    lv_timer_del(timer_zidan_fly);

    init_shine_zb();      // 重置游戏对象
    lv_obj_clean(screen); // 清理屏幕
    lv_obj_del(screen);   // 删除屏幕
}
static void reset_pvz_game(void)
{
    //stop_pvz_game();
    lv_obj_clean(exit_ui); // 清理退出界面

}


static lv_obj_t *pvz_screen_old;
/* 重新开始游戏回调函数示例 */
static void restart_game_cb(lv_event_t *e)
{
    lv_event_code_t code = lv_event_get_code(e);
    if (code == LV_EVENT_CLICKED) {
        pvz_screen_old = screen;
        // 实现游戏重置逻辑
        reset_pvz_game();
        // 重新进入游戏界面
        pvz_start();
    }
}
/*
* 退出游戏回调,释放资源并回退到游戏选中界面
*/
static void exit_game_cb(lv_event_t *e)
{
    // if (e) {//e==NULL 不是真实的
    //     //修改过音频参数了
    //    // renew_codec_fs(); // 重新设置音频参数
    //     app_sr_init(); // 重新初始化音频资源
    // }

   // ESP_LOGE(TAG, "bug game 2");
    reset_pvz_game();
    stop_bg_music();
    //回退到游戏选中界面
    game_backspace();
   // ESP_LOGE(TAG, "bug game 3");
    /*要等背景音乐任务pvz_bg_music_task退出后才能app_sr_init，因为i2s_channel_disable*/
    if (get_voice_control()) //有开启语音控制则提示用户
    {
        vTaskDelay(pdMS_TO_TICKS(300)); // 延时300ms

        //  ESP_LOGE(TAG, "bug game 1");
        app_sr_init();    // 重新初始化音频资源
        renew_codec_fs(); // 重新设置音频参数
    }
}
/*
* @brief  创建退出界面
* 在游戏失败时显示退出界面，包含提示图片和操作按钮
*/
static void create_exit_ui(void)
{
    stop_pvz_game();
    // 创建失败提示图片
    exit_ui = lv_img_create(lv_scr_act());
    lv_img_set_src(exit_ui, &gameFail);
    lv_obj_center(exit_ui); // 居中显示图片

    // 创建按钮容器 (用于水平排列两个按钮)
    lv_obj_t *btn_container = lv_obj_create(exit_ui);
    lv_obj_remove_style_all(btn_container);                // 移除默认样式
    lv_obj_set_style_text_font(btn_container, &myFont, 0); // 设置字体

    // 设置容器尺寸和位置 (适应320x240分辨率)
    lv_obj_set_size(btn_container, 220, 38); // 容器宽度占满屏幕
    lv_obj_set_pos(btn_container, 40, 180);// 容器位置在图片下方15像素
    //lv_obj_align_to(btn_container, exit_ui, LV_ALIGN_OUT_BOTTOM_MID, 0, 15); // 图片下方15像素

    // 创建重新开始按钮 - 绿色风格
    lv_obj_t *btn_restart = lv_btn_create(btn_container);
    lv_obj_set_size(btn_restart, 100, 38);
    lv_obj_set_style_bg_color(btn_restart, lv_color_hex(0x4CAF50), LV_STATE_DEFAULT); // 绿色背景
    lv_obj_set_style_bg_color(btn_restart, lv_color_hex(0x388E3C), LV_STATE_PRESSED); // 按下时深绿色
    lv_obj_set_style_text_color(btn_restart, lv_color_white(), 0);                    // 白色文字

    // 按钮居中排列 (使用flex布局)
    lv_obj_set_flex_flow(btn_container, LV_FLEX_FLOW_ROW);           // 水平排列
    lv_obj_set_flex_align(btn_container, LV_FLEX_ALIGN_SPACE_AROUND, // 均匀分布
                          LV_FLEX_ALIGN_CENTER, LV_FLEX_ALIGN_CENTER);

    // 添加按钮标签
    lv_obj_t *label_restart = lv_label_create(btn_restart);
    lv_label_set_text(label_restart, "重新开始");
    lv_obj_center(label_restart);
    lv_obj_add_event_cb(btn_restart, restart_game_cb, LV_EVENT_CLICKED, NULL); // 添加回调

    // 创建退出按钮 - 红色风格
    lv_obj_t *btn_exit = lv_btn_create(btn_container);
    lv_obj_set_size(btn_exit, 100, 38);
    lv_obj_set_style_bg_color(btn_exit, lv_color_hex(0xF44336), LV_STATE_DEFAULT); // 红色背景
    lv_obj_set_style_bg_color(btn_exit, lv_color_hex(0xD32F2F), LV_STATE_PRESSED); // 按下时深红色
    lv_obj_set_style_text_color(btn_exit, lv_color_white(), 0);                    // 白色文字

    // 添加按钮标签
    lv_obj_t *label_exit = lv_label_create(btn_exit);
    lv_label_set_text(label_exit, "退出游戏");
    lv_obj_center(label_exit);
    lv_obj_add_event_cb(btn_exit, exit_game_cb, LV_EVENT_CLICKED, NULL); // 添加回调
}



/*背景音乐播放*/
// 声明开机音乐PCM数据（由二进制文件嵌入）
extern const uint8_t pvz_music_pcm_start[] asm("_binary_pvz_bg_pcm_start");
extern const uint8_t pvz_music_pcm_end[] asm("_binary_pvz_bg_pcm_end");

// 错误原因描述
static const char err_reason[][30] = {
    "input param is invalid", // 参数错误
    "operation timeout"       // 操作超时
};

// 游戏音乐播放任务（循环版）
void pvz_bg_music_task(void *pvParameters)
{
    esp_err_t ret = ESP_OK;
    size_t bytes_write = 0;
    const size_t music_size = pvz_music_pcm_end - pvz_music_pcm_start;
    const size_t chunk_size = 4096; // 每次写入的块大小

    i2s_chan_handle_t aduio_tx_chan = get_i2s_tx_chan();

    pa_en(1); // 使能功放

    while (music_playing) {
        uint8_t *data_ptr = (uint8_t *)pvz_music_pcm_start;
        size_t remaining = music_size;

        /* 禁用并预加载首块数据 */
        //!这里默认i2s是禁止的，
        i2s_channel_disable(aduio_tx_chan); // I2S_CHAN_STATE_READY
        ESP_ERROR_CHECK(i2s_channel_preload_data(aduio_tx_chan, data_ptr, chunk_size, &bytes_write));
        data_ptr += bytes_write;
        remaining -= bytes_write;
        ESP_ERROR_CHECK(i2s_channel_enable(aduio_tx_chan));

        /* 分块写入剩余数据 */
        while (remaining > 0 && music_playing) {
            size_t write_size = (remaining > chunk_size) ? chunk_size : remaining;

            ret = i2s_channel_write(aduio_tx_chan, data_ptr, write_size, &bytes_write, pdMS_TO_TICKS(500));

            if (ret != ESP_OK) {
                if (ret == ESP_ERR_TIMEOUT) {
                    ESP_LOGW(TAG, "[music] I2S write timeout");
                } else {
                    ESP_LOGE(TAG, "[music] I2S write error: %d", ret);
                    break;
                }
            }

            data_ptr += bytes_write;
            remaining -= bytes_write;
        }
    }

    /* 清理资源 */
   // i2s_channel_disable(aduio_tx_chan);
    pa_en(0); // 关闭功放
    ESP_LOGI(TAG, "[music] 背景音乐任务结束");
    music_task_handle = NULL;
    vTaskDelete(NULL);
}

// static void user_enter_cb(void)
// {
//     music_playing = true;
//     xTaskCreate(pvz_bg_music_task, "pvz_music", 4096, NULL, 5, &music_task_handle);
// }
// static void user_exit_cb(void)
// {
//     exit_game_cb(NULL);
// }



/* 启动背景音乐 */
void start_bg_music(void)
{
    if (music_task_handle)
        return; // 防止重复创建
    if (get_voice_control())//有开启语音控制则提示用户
    {
        //todo 因为这个游戏界面是基于 lv_scr_act 的，而reminder_voice_clash_ui也是，这样就会有bug
        // reminder_voice_clash_ui(CODEC_DEFAULT_SAMPLE_RATE, 16, 2, user_enter_cb, user_exit_cb);
        // return;
        app_sr_deinit();
        bsp_codec_set_fs(CODEC_DEFAULT_SAMPLE_RATE, 16, 2); // 设置音频参数为用户设置参数
    }
    music_playing = true;
    xTaskCreate(pvz_bg_music_task, "pvz_music", 4096, NULL, 5, &music_task_handle);
}

/* 停止背景音乐 */
void stop_bg_music(void)
{
    if (!music_task_handle)
        return;

    music_playing = false; // 设置停止标志

    // 等待任务安全退出（最多等待1ms）
    for (int i = 0; i < 50 && music_task_handle; i++) {
        vTaskDelay(pdMS_TO_TICKS(20));
    }

    // 强制终止任务（如果未正常退出）
    if (music_task_handle) {
        i2s_chan_handle_t aduio_tx_chan = get_i2s_tx_chan();
        /* 清理资源 */
       // i2s_channel_disable(aduio_tx_chan);
        pa_en(0); // 关闭功放
        vTaskDelete(music_task_handle);
        music_task_handle = NULL;
    }
}